const db = wx.cloud.database();
const _ = db.command;
const app = getApp()

Page({
  data: {
    beforeTime:null,
    afterTime:null,
    itemCount: 0,
    venueName: '',
    project:"",
    venueDescription: '',
    selectedTimes: [],  // 保存选中的时间段
    selectedTime: [],  // 当前选中的时间段（两个时间点）
    showModal: false,
    selectedVenue: null,  // 当前选中的场地
    selectedProject: true,  // 用来判断是否显示场地选择部分的标志
    availableVenues: [], // 当前选择的项目对应的场地
    venues: {
      羽毛球: ['羽毛球场1', '羽毛球场2', '羽毛球场3', '羽毛球场4', '羽毛球场5', '羽毛球场6', '羽毛球场7', '羽毛球场8'],
      篮球: ['篮球场1', '篮球场2', '篮球场3'],
      排球: ['排球场1', '排球场2', '排球场3', '排球场4'],
      足球: ['足球场']
    },
    availableTimes: [
      [
        '06:30', '07:00', '07:30', '08:00', '08:30', '09:00', '09:30', '10:00', 
        '10:30', '11:00', '11:30', '12:00', '12:30', '13:00', '13:30', '14:00', 
        '14:30', '15:00', '15:30', '16:00', '16:30', '17:00', '17:30', '18:00', 
        '18:30', '19:00', '19:30', '20:00', '20:30', '21:00', '21:30', '22:00'
      ]
    ]
  },

  selectProject: function(event) {
    const project = event.currentTarget.dataset.project;
    this.data.project = project
    this.setData({
      selectedProject: project,
      selectedVenue: '', // 重置场地选择
      selectedTime: [],  // 重置时间选择
      availableVenues: this.data.venues[project] // 根据项目更新场地
    });
  },
  

  selectVenue: function(event) {
    const venue = event.currentTarget.dataset.venue;
    let availableVenues = this.data.availableVenues;

    // 如果选中的场地已经在数组中，将其移到最前面
    if (availableVenues.indexOf(venue) > -1) {
      availableVenues = [venue, ...availableVenues.filter(item => item !== venue)];
    }

    // 更新选中的场地和场地列表
    this.setData({
      selectedVenue: venue,
      availableVenues: availableVenues
    });
  },

  showTimePicker: function() {
    this.data.selectedTime = this.data.selectedTimes;
    this.data.selectedTime.sort();  // 排序选中的时间段
    this.setData({
      selectedTime: this.data.selectedTime,
      showModal: true // 显示确认弹出框
    });
  },
  
  onTimeClick: function(event) {
    const clickedTime = event.currentTarget.dataset.time;
    let selectedTimes = this.data.selectedTimes;
    console.log(this.data.selectedTimes)
    console.log(clickedTime)
    if (this.data.beforeTime >= clickedTime || this.data.afterTime <= clickedTime){
      wx.showToast({
        title: '无法预定时间，请修改',
        icon: 'none'
      });
      console.log("yes")
    }
    else{
      console.log("no")
        // 如果选中的时间已存在，则移除它
      if (selectedTimes.indexOf(clickedTime) !== -1) {
        selectedTimes = selectedTimes.filter(time => time !== clickedTime);
      } 
      // 如果未选中且还未选两个时间，则直接添加
      else if (selectedTimes.length < 2) {
        selectedTimes.push(clickedTime);
      } 
      // 如果已经选中两个时间，则删除第一个，并添加当前选中的时间
      else {
        selectedTimes.shift();  // 删除第一个选中的时间
        selectedTimes.push(clickedTime);  // 添加当前选中的时间
      }
      let beforeTime = null;
      let afterTime = null;
      // 更新 selectedTimes 数据
      this.setData({
        itemCount: selectedTimes.length,
        selectedTimes: selectedTimes,
        beforeTime: beforeTime,
        afterTime: afterTime
      });
          // 当选择一个时间时，查找该时间点之前和之后未预约满的时间
      if (selectedTimes.length === 1) {
        this.findAvailableTimes(clickedTime);
      }
    }

    
  
    // 当选择两个时间时，检查该时间段内场地的预定情况
    if (selectedTimes.length === 2) {
      this.checkAvailableSlots(selectedTimes[0], selectedTimes[1]);
    }
  },


  findAvailableTimes: function(clickedTime) {
    const selectedVenue = this.data.selectedVenue;  // 获取当前场地名称
  
    // 查询数据库，查找当前场地的所有预约时间数据
    wx.cloud.database().collection('PC')
      .where({
        venue: selectedVenue  // 根据场地名查询
      })
      .get()
      .then(res => {
        // 假设只有一条场地数据返回
        if (res.data.length === 0) {
          console.log('未找到该场地的预约数据');
          return;
        }
  
        const timeData = res.data[0];  // 获取查询结果中的第一条数据
  
        // 获取场地的所有时间点
        const allTimes = Object.keys(timeData).filter(key => key !== 'venue');  // 去掉 venue 字段，获取所有时间点
        
        console.log(allTimes)
        let beforeTime = null;
        let afterTime = null;
  
        // 查找点击时间点之前未预约满的时间点
        for (let i = allTimes.indexOf(clickedTime) - 1; i >= 0; i--) {
          if (timeData[allTimes[i]] >= 10) {  // 假设每个时间点最多预约10人
            beforeTime = allTimes[i];
            break;
          }
        }
  
        // 查找点击时间点之后未预约满的时间点
        for (let i = allTimes.indexOf(clickedTime) + 1; i < allTimes.length; i++) {
          if (timeData[allTimes[i]] >= 10) {  // 假设每个时间点最多预约10人
            afterTime = allTimes[i];
            break;
          }
        }
  
        // 输出或处理找到的时间点
        console.log('Before time:', beforeTime);
        console.log('After time:', afterTime);
        
        // 更新数据
        this.setData({
          beforeTime: beforeTime,
          afterTime: afterTime
        });
      })
      .catch(err => {
        console.error('查询失败:', err);
      });
  },
  


  checkAvailableSlots: function(startTime, endTime) {
    const { selectedVenue } = this.data;
  
    if (!selectedVenue) {
      wx.showToast({
        title: '请选择场地',
        icon: 'none'
      });
      return;
    }
  
    // 假设时间段字段名是类似 "06:30", "07:00", "07:30" 等
    const timeSlots = [
      '06:30', '07:00', '07:30', '08:00', '08:30', '09:00', '09:30', '10:00', 
        '10:30', '11:00', '11:30', '12:00', '12:30', '13:00', '13:30', '14:00', 
        '14:30', '15:00', '15:30', '16:00', '16:30', '17:00', '17:30', '18:00', 
        '18:30', '19:00', '19:30', '20:00', '20:30', '21:00', '21:30', '22:00'
      // 更多时间段...
    ];
  
    // 筛选符合时间范围的时间段
    const filteredSlots = timeSlots.filter(slot => {
      return slot >= startTime && slot < endTime;
    });
  
    // 如果没有符合条件的时间段，直接返回
    if (filteredSlots.length === 0) {
      this.setData({
        availableSlots: 0
      });
      return;
    }
  
    // 查询数据库获取指定场地在指定时间段的预定情况
    db.collection('PC')  // 假设数据库集合名为 "PC"
      .where({
        venue: selectedVenue
      })
      .get()
      .then(res => {
        let availableSlots = 10;  // 可用名额
        const maxSlotsPerTime = 10;  // 每个时间段最多10个名额
  
        // 遍历查询结果
        res.data.forEach(record => {
          filteredSlots.forEach(timeSlot => {
            if (record.hasOwnProperty(timeSlot)) {
              const reserved = record[timeSlot];  // 获取某个时间段的已预定数量
              console.log(reserved)
              console.log(maxSlotsPerTime - reserved)
              availableSlots = Math.min(availableSlots, maxSlotsPerTime - reserved);  // 计算可预定名额

            }
          });
        });
  
        console.log('Available slots:', availableSlots);
        
        // 更新页面数据
        this.setData({
          availableSlots: availableSlots  // 更新可预定名额
        });
      })
      .catch(err => {
        wx.showToast({
          title: '查询失败',
          icon: 'none'
        });
        console.error(err);
      });
  },
  

  confirmBooking: function() {
    const { selectedProject, selectedVenue, selectedTimes } = this.data;
  
    // 检查是否已经选择了完整的时间段
    if (selectedTimes.length === 2) {
      // 需要处理预约人数的更新
      this.updateReservation(selectedProject, selectedVenue, selectedTimes);
    } else {
      wx.showToast({
        title: '请完整选择时间段',
        icon: 'none'
      });
    }
  },

  updateReservation: function(project, venue, selectedTimes) {
    const db = wx.cloud.database();
    const timeSlots = selectedTimes.sort();  // 确保时间段按顺序排列
    const startTime = timeSlots[0];  // 第一个时间段
    const endTime = timeSlots[1];    // 第二个时间段
  
    // 获取从startTime到endTime的所有半小时间隔的时间段，排除endTime
    const timeRange = this.generateTimeRange(startTime, endTime);
    
    // 获取当前时间段的预约数据
    db.collection('PC')
      .where({
        venue: venue  // 根据场地名查询
      })
      .get()
      .then(res => {
        if (res.data.length === 0) {
          wx.showToast({
            title: '该场地没有预约数据',
            icon: 'none'
          });
          return;
        }
  
        const timeData = res.data[0];  // 获取场地的预约数据
        const maxSlotsPerTime = 10;     // 每个时间段最多预约10人
        let isAvailable = true;
  
        // 检查所选时间段是否有可预约的名额
        timeRange.forEach(timeSlot => {
          const currentReservationCount = parseInt(timeData[timeSlot], 10) || 0;
          if (currentReservationCount >= maxSlotsPerTime) {
            isAvailable = false;  // 如果某个时间段已满，标记为不可预约
          }
        });
  
        if (!isAvailable) {
          wx.showToast({
            title: '该时间段已满',
            icon: 'none'
          });
          return;
        }
  
        // 如果有空余名额，进行更新预约
        const updates = {};
        timeRange.forEach(timeSlot => {
          const currentCount = parseInt(timeData[timeSlot], 10);
          updates[timeSlot] = (currentCount + 1).toString();  // 每个时间段增加 1
        });
  
        // 更新数据库，增加预约人数
        db.collection('PC')
          .where({
            venue: venue  // 根据场地进行更新
          })
          .update({
            data: updates
          })
          .then(() => {
            wx.showToast({
              title: '预约成功',
              icon: 'success'
            });
            // 获取当前预约的信息（假设这些信息已经保存在页面的 data 中，或者是通过参数传递过来的）
            const bookingData = {
              sportsItem: this.data.project,  // 当前选择的体育项目
              venue: this.data.selectedVenue,             // 当前选择的场地
              time: this.data.selectedTime,               // 当前选择的时间
              userId: app.globalData.occupation,
              xuehao: app.globalData.account
            };

            // 使用云数据库存储预约数据
            const db = wx.cloud.database();
            db.collection('PC').add({
              data: {
                sportsItem: bookingData.sportsItem,  // 体育项目
                venue1: bookingData.venue,            // 场地
                time: bookingData.time,              // 时间
                userId: bookingData.userId,
                xuhao1: bookingData.xuehao
              },
              success: res => {
                console.log('预约信息存储成功', res);
                // 成功后调用 resetBooking 重置预约数据
                this.resetBooking();
              },
              fail: err => {
                console.error('预约信息存储失败', err);
                wx.showToast({
                  title: '预约失败，请稍后再试',
                  icon: 'none'
                });
              }
            });
            this.resetBooking();  // 重置预约数据

          })
          .catch(err => {
            wx.showToast({
              title: '更新失败',
              icon: 'none'
            });
            console.error('更新预约失败:', err);
          });
      })
      .catch(err => {
        wx.showToast({
          title: '查询失败',
          icon: 'none'
        });
        console.error('查询预约数据失败:', err);
      });
  },
  
  // 生成时间段列表，假设时间间隔为半小时，但去掉最后一个时间点
  generateTimeRange: function(startTime, endTime) {
    const timeRange = [];
    let currentTime = startTime;
  
    // 持续生成半小时间隔的时间段，直到达到结束时间之前
    while (this.isBefore(currentTime, endTime)) {
      timeRange.push(currentTime);
      
      // 计算下一个半小时的时间
      const [hour, minute] = currentTime.split(':').map(num => parseInt(num, 10));
      let nextHour = hour;
      let nextMinute = minute + 30;
      if (nextMinute === 60) {
        nextMinute = 0;
        nextHour += 1;
      }
  
      // 格式化时间为 2 位数
      currentTime = `${String(nextHour).padStart(2, '0')}:${String(nextMinute).padStart(2, '0')}`;
    }
  
    // 不添加endTime，返回倒数第二个时间点为最后一个时间段
    return timeRange;
  },
  
  // 判断时间currentTime是否在endTime之前
  isBefore: function(currentTime, endTime) {
    const [currentHour, currentMinute] = currentTime.split(':').map(num => parseInt(num, 10));
    const [endHour, endMinute] = endTime.split(':').map(num => parseInt(num, 10));
  
    if (currentHour < endHour) return true;
    if (currentHour === endHour && currentMinute < endMinute) return true;
    return false;
  },

  

  
  resetBooking: function() {
    this.setData({
      itemCount: 0,
      selectedTimes: [],
      selectedTime: [],
      selectedProject: '',
      selectedVenue: '',
      showModal: false,
      availableSlots: 0
    });
  },
  

  cancelBooking: function() {
    this.setData({
      showModal: false
    });
  },

  resetBooking: function() {
    this.setData({
      itemCount: 0,
      selectedTimes: [],
      selectedTime: [],
      selectedProject: '',
      selectedVenue: '',
      showModal: false,
      availableSlots: 0
    });
  },

  onLoad: function(options) {
    console.log(options);
    this.setData({
      venueName: options.id, // 从参数或数据库获取
      venueDescription: '' // 从参数或数据库获取
    });
  },

  onShow() {},
  onHide() {},
  onUnload() {},
  onPullDownRefresh() {},
  onReachBottom() {},
  onShareAppMessage() {}
});
